home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 101-125 / 118 / empire / src / source.zoo / parse.d < prev    next >
Text File  |  1987-12-02  |  15KB  |  807 lines
  1. #include:util.g
  2. #empire.g
  3. #empfunc.g
  4.  
  5. /*
  6.  * skipBlanks - skip past blanks in input line.
  7.  */
  8.  
  9. proc skipBlanks()void:
  10.  
  11.     while InputPtr* = ' ' or InputPtr* = '\t' do
  12.     InputPtr := InputPtr + 1;
  13.     od;
  14. corp;
  15.  
  16. /*
  17.  * doSkipBlanks - skip blanks, return 'true'
  18.  */
  19.  
  20. proc doSkipBlanks()bool:
  21.  
  22.     skipBlanks();
  23.     true
  24. corp;
  25.  
  26. /*
  27.  * skipWord - skip up to a blank on the input line.
  28.  */
  29.  
  30. proc skipWord()void:
  31.  
  32.     while InputPtr* ~= ' ' and InputPtr* ~= '\t' and InputPtr* ~= '\e' do
  33.     InputPtr := InputPtr + 1;
  34.     od;
  35. corp;
  36.  
  37. /*
  38.  * getNumber - read in a number.
  39.  */
  40.  
  41. proc getNumber(*int pNum)bool:
  42.     int n;
  43.     bool isNeg;
  44.  
  45.     if InputPtr* = '-' then
  46.     isNeg := true;
  47.     InputPtr := InputPtr + 1;
  48.     elif InputPtr* = '+' then
  49.     isNeg := false;
  50.     InputPtr := InputPtr + 1;
  51.     else
  52.     isNeg := false;
  53.     fi;
  54.     if InputPtr* >= '0' and InputPtr* <= '9' then
  55.     n := 0;
  56.     while InputPtr* >= '0' and InputPtr* <= '9' do
  57.         n := n * 10 + (InputPtr* - '0');
  58.         InputPtr := InputPtr + 1;
  59.     od;
  60.     pNum* := if isNeg then -n else n fi;
  61.     true
  62.     else
  63.     if InputPtr* = '\e' then
  64.         err("missing number");
  65.     else
  66.         err("invalid number");
  67.         InputPtr* := '\e';
  68.     fi;
  69.     false
  70.     fi
  71. corp;
  72.  
  73. /*
  74.  * reqNumber - get (and prompt for if needed) a number.
  75.  */
  76.  
  77. proc reqNumber(*int pN; *char prompt)bool:
  78.     bool gotOne;
  79.     ushort stat;
  80.  
  81.     if InputPtr* = '\e' then
  82.     while
  83.         write(PromptOut; prompt);
  84.         if readln(Chin; pN*) then
  85.         gotOne := true;
  86.         false
  87.         else
  88.         stat := ioerror(Chin);
  89.         if stat = CH_MISSING or stat = CH_EOF then
  90.             if stat = CH_MISSING then
  91.             readln(Chin;);
  92.             fi;
  93.             gotOne := false;
  94.             false
  95.         else
  96.             readln(Chin;);
  97.             true
  98.         fi
  99.         fi
  100.     do
  101.         err("invalid number, try again");
  102.     od;
  103.     gotOne
  104.     else
  105.     getNumber(pN)
  106.     fi
  107. corp;
  108.  
  109. /*
  110.  * getPosRange - get a positive value less than or equal to a given amount
  111.  */
  112.  
  113. proc getPosRange(*uint pQuan; uint maximum)bool:
  114.     int n;
  115.  
  116.     if getNumber(&n) then
  117.     if n < 0 or make(n, uint) > maximum then
  118.         writeln(PromptOut; "*** value must be 0 - ", maximum, " ***");
  119.         false
  120.     else
  121.         pQuan* := n;
  122.         true
  123.     fi
  124.     else
  125.     false
  126.     fi
  127. corp;
  128.  
  129. /*
  130.  * reqPosRange - get/request a positive value
  131.  */
  132.  
  133. proc reqPosRange(*uint pQuan; uint maximum; *char prompt)bool:
  134.     bool gotOne;
  135.  
  136.     if InputPtr* = '\e' then
  137.     gotOne := true;
  138.     while
  139.         write(PromptOut; prompt);
  140.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  141.             InputBuffer[0] = '\e' then
  142.         gotOne := false;
  143.         false
  144.         else
  145.         InputPtr := &InputBuffer[0];
  146.         skipBlanks();
  147.         not getPosRange(pQuan, maximum)
  148.         fi
  149.     do
  150.     od;
  151.     gotOne
  152.     else
  153.     getPosRange(pQuan, maximum)
  154.     fi
  155. corp;
  156.  
  157. /*
  158.  * getPosRange1 - get a number within a given range, with 1 decimal digit.
  159.  */
  160.  
  161. proc getPosRange1(*uint pNumber; uint maximum)bool:
  162.     uint n;
  163.     bool hadDecimal, bad;
  164.  
  165.     hadDecimal := false;
  166.     if InputPtr* >= '0' and InputPtr* <= '9' or InputPtr* = '.' then
  167.     n := 0;
  168.     while InputPtr* >= '0' and InputPtr* <= '9' do
  169.         n := n * 10 + (InputPtr* - '0');
  170.         InputPtr := InputPtr + 1;
  171.     od;
  172.     if InputPtr* = '.' then
  173.         InputPtr := InputPtr + 1;
  174.         if InputPtr* >= '0' and InputPtr* <= '9' then
  175.         n := n * 10 + (InputPtr* - '0');
  176.         InputPtr := InputPtr + 1;
  177.         while InputPtr* >= '0' and InputPtr* <= '9' do
  178.             InputPtr := InputPtr + 1;
  179.         od;
  180.         else
  181.         n := n * 10;
  182.         fi;
  183.     else
  184.         n := n * 10;
  185.     fi;
  186.     if InputPtr* ~= '\e' and InputPtr* ~= ' ' and InputPtr* ~= '\t' then
  187.         err("invalid digit");
  188.         bad := true;
  189.     fi;
  190.     else
  191.     err("invalid digit");
  192.     bad := true;
  193.     fi;
  194.     if not bad then
  195.     if n > maximum then
  196.         err("value too large");
  197.         bad := true;
  198.     else
  199.         pNumber* := n;
  200.     fi;
  201.     fi;
  202.     if bad then
  203.     InputPtr* := '\e';
  204.     fi;
  205.     not bad
  206. corp;
  207.  
  208. /*
  209.  * reqPosRange1 - req a number within a given range, with 1 decimal digit.
  210.  */
  211.  
  212. proc reqPosRange1(*uint pNumber; uint maximum; *char prompt)bool:
  213.     bool gotOne;
  214.  
  215.     if InputPtr* = '\e' then
  216.     gotOne := true;
  217.     while
  218.         write(PromptOut; prompt);
  219.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  220.             InputBuffer[0] = '\e' then
  221.         gotOne := false;
  222.         false
  223.         else
  224.         InputPtr := &InputBuffer[0];
  225.         skipBlanks();
  226.         not getPosRange1(pNumber, maximum)
  227.         fi
  228.     do
  229.     od;
  230.     gotOne
  231.     else
  232.     getPosRange1(pNumber, maximum)
  233.     fi
  234. corp;
  235.  
  236. /*
  237.  * getPair - get a coordinate pair.
  238.  */
  239.  
  240. proc getPair(*int pA, pB)bool:
  241.  
  242.     if getNumber(pA) then
  243.     if InputPtr* = ':' then
  244.         InputPtr := InputPtr + 1;
  245.         getNumber(pB)
  246.     elif InputPtr* = ',' or InputPtr* = '?' or InputPtr* = ' ' or
  247.         InputPtr* = '\t' or InputPtr* = '/' or InputPtr* = '\e' then
  248.         pB* := pA*;
  249.         true
  250.     else
  251.         err("missing ':' for coordinate pair");
  252.         InputPtr* := '\e';
  253.         false
  254.     fi
  255.     else
  256.     false
  257.     fi
  258. corp;
  259.  
  260. /*
  261.  * getBox - get a pair of sector designations (a rectangle).
  262.  */
  263.  
  264. proc getBox(*int pA, pB, pC, pD)bool:
  265.     uint i;
  266.  
  267.     if InputPtr* = '\#' then
  268.     InputPtr := InputPtr + 1;
  269.     if InputPtr* >= '0' and InputPtr* <= '3' or InputPtr* = '\e' or
  270.         InputPtr* = ' ' or InputPtr* = '\t' or
  271.         InputPtr* = '/' or InputPtr* = '?' then
  272.         if InputPtr* >= '0' and InputPtr* <= '0' + (REALM_MAX - 1) then
  273.         i := InputPtr* - '0';
  274.         InputPtr := InputPtr + 1;
  275.         else
  276.         i := 0;
  277.         fi;
  278.         pA* := ThisCountry*.c_realms[i].r_top;
  279.         pB* := ThisCountry*.c_realms[i].r_bottom;
  280.         pC* := ThisCountry*.c_realms[i].r_left;
  281.         pD* := ThisCountry*.c_realms[i].r_right;
  282.     fi;
  283.     if InputPtr* ~= ' ' and InputPtr* ~= '\e' and InputPtr* ~= '\t' and
  284.         InputPtr* ~= '/' and InputPtr* ~= '?' then
  285.         err("illegal characters in realm");
  286.         InputPtr* := '\e';
  287.         false
  288.     else
  289.         true
  290.     fi
  291.     elif getPair(pA, pB) then
  292.     if InputPtr* = ',' then
  293.         InputPtr := InputPtr + 1;
  294.         if getPair(pC, pD) then
  295.         if pA* > pB* then
  296.             err("top > bottom");
  297.             false
  298.         elif pC* > pD* then
  299.             err("right > left");
  300.             false
  301.         else
  302.             true
  303.         fi
  304.         else
  305.         false
  306.         fi
  307.     else
  308.         err("missing ',' for sectors specification");
  309.         InputPtr* := '\e';
  310.         false
  311.     fi
  312.     else
  313.     false
  314.     fi
  315. corp;
  316.  
  317. /*
  318.  * reqBox - get (prompting for if necessary) a rectangle specification.
  319.  */
  320.  
  321. proc reqBox(*int pA, pB, pC, pD; *char prompt)bool:
  322.     bool gotOne;
  323.  
  324.     if InputPtr* = '\e' then
  325.     gotOne := true;
  326.     while
  327.         write(PromptOut; prompt);
  328.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  329.             InputBuffer[0] = '\e' then
  330.         gotOne := false;
  331.         false
  332.         else
  333.         InputPtr := &InputBuffer[0];
  334.         skipBlanks();
  335.         not getBox(pA, pB, pC, pD)
  336.         fi
  337.     do
  338.     od;
  339.     gotOne
  340.     else
  341.     getBox(pA, pB, pC, pD)
  342.     fi
  343. corp;
  344.  
  345. /*
  346.  * getSector - get a coordinate pair.
  347.  */
  348.  
  349. proc getSector(*int pA, pB)bool:
  350.  
  351.     if getNumber(pA) then
  352.     if InputPtr* = ',' then
  353.         InputPtr := InputPtr + 1;
  354.         getNumber(pB)
  355.     else
  356.         err("missing ',' for sector number");
  357.         InputPtr* := '\e';
  358.         false
  359.     fi
  360.     else
  361.     false
  362.     fi
  363. corp;
  364.  
  365. /*
  366.  * reqSector - get (prompting if needed) a single sector spec.
  367.  */
  368.  
  369. proc reqSector(*int pA, pB; *char prompt)bool:
  370.     bool gotOne;
  371.  
  372.     if InputPtr* = '\e' then
  373.     gotOne := true;
  374.     while
  375.         write(PromptOut; prompt);
  376.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  377.             InputBuffer[0] = '\e' then
  378.         gotOne := false;
  379.         false
  380.         else
  381.         InputPtr := &InputBuffer[0];
  382.         skipBlanks();
  383.         not getSector(pA, pB)
  384.         fi
  385.     do
  386.     od;
  387.     gotOne
  388.     else
  389.     getSector(pA, pB)
  390.     fi
  391. corp;
  392.  
  393. /*
  394.  * reqChar - get (prompting if needed) a character in the given set.
  395.  */
  396.  
  397. proc reqChar(*char pChar, validSet, prompt, errMess)bool:
  398.     *char p;
  399.     char ch;
  400.  
  401.     if InputPtr* = '\e' then
  402.     while
  403.         write(PromptOut; prompt);
  404.         if readln(Chin; ch) then
  405.         p := validSet;
  406.         while p* ~= ch and p* ~= '\e' do
  407.             p := p + 1;
  408.         od;
  409.         if p* = '\e' then
  410.             err(errMess);
  411.             true
  412.         else
  413.             false
  414.         fi
  415.         else
  416.         pretend(ioerror(Chin), void);
  417.         readln(Chin;);
  418.         ch := ' ';
  419.         false
  420.         fi
  421.     do
  422.     od;
  423.     pChar* := ch;
  424.     ch ~= ' '
  425.     else
  426.     ch := InputPtr*;
  427.     InputPtr := InputPtr + 1;
  428.     while validSet* ~= ch and validSet* ~= '\e' do
  429.         validSet := validSet + 1;
  430.     od;
  431.     if validSet* = '\e' then
  432.         err(errMess);
  433.         false
  434.     else
  435.         pChar* := ch;
  436.         if InputPtr* ~= '\e' and InputPtr* ~= ' ' and
  437.             InputPtr* ~= '\t' then
  438.         err("excess characters after type on command line");
  439.         false
  440.         else
  441.         true
  442.         fi
  443.     fi
  444.     fi
  445. corp;
  446.  
  447. /*
  448.  * reqCmsgpob - get (prompting if needed) a cmsgpob type.
  449.  */
  450.  
  451. proc reqCmsgpob(*ItemType_t pWhich; *char prompt)bool:
  452.     char ch;
  453.  
  454.     if reqChar(&ch, &ItemChar[0], prompt, "invalid item type") then
  455.     pWhich* := getIndex(&ItemChar[0], ch) + it_first;
  456.     true
  457.     else
  458.     false
  459.     fi
  460. corp;
  461.  
  462. /*
  463.  * reqDesig - get (prompting if needed) a sector designation character.
  464.  */
  465.  
  466. proc reqDesig(*SectorType_t pDesig; *char prompt)bool:
  467.     char ch;
  468.  
  469.     if reqChar(&ch, &SectorChar[0], prompt, "invalid sector designation") then
  470.     pDesig* := getIndex(&SectorChar[0], ch) + s_first;
  471.     true
  472.     else
  473.     false
  474.     fi
  475. corp;
  476.  
  477. /*
  478.  * reqShipType - get a ship type character.
  479.  */
  480.  
  481. proc reqShipType(*ShipType_t pType; *char prompt)bool:
  482.     char ch;
  483.  
  484.     if reqChar(&ch, &ShipChar[0], prompt, "invalid ship type") then
  485.     pType* := getIndex(&ShipChar[0], ch) + st_first;
  486.     true
  487.     else
  488.     false
  489.     fi
  490. corp;
  491.  
  492. /*
  493.  * reqBridgeDirection - get a bridge span building direction.
  494.  */
  495.  
  496. proc reqBridgeDirection(*char pDir, prompt)bool:
  497.  
  498.     reqChar(pDir, "udlr", prompt, "invalid span direction")
  499. corp;
  500.  
  501. /*
  502.  * getCountry - get a country name or number from the input line.
  503.  */
  504.  
  505. proc getCountry(*uint pCountry)bool:
  506.     *char name, p;
  507.     int n;
  508.     uint n1;
  509.  
  510.     if InputPtr* = '\e' then
  511.     false
  512.     elif InputPtr* >= '0' and InputPtr* <= '9' then
  513.     if getNumber(&n) then
  514.         n1 := n;
  515.         if n >= 0 and n1 < World.w_currCountries then
  516.         pCountry* := n1;
  517.         true
  518.         elif ThisCountryNumber = DEITY and n >= 0 and
  519.             n1 < World.w_maxCountries then
  520.         pCountry* := n1;
  521.         writeln(PromptOut;);
  522.         writeln(PromptOut;);
  523.         writeln(PromptOut;
  524.             "*** Warning - this country is still inactive ***");
  525.         writeln(PromptOut;);
  526.         writeln(PromptOut;);
  527.         true
  528.         else
  529.         err("country number out of range");
  530.         false
  531.         fi
  532.     else
  533.         false
  534.     fi
  535.     else
  536.     name := InputPtr;
  537.     skipWord();
  538.     p := InputPtr;
  539.     skipBlanks();
  540.     p* := '\e';
  541.     n1 := 0;
  542.     while n1 < World.w_currCountries and
  543.         not CharsEqual(name, &Country[n1].c_name[0]) do
  544.         n1 := n1 + 1;
  545.     od;
  546.     if n1 = World.w_currCountries then
  547.         err("no country by that name");
  548.         false
  549.     else
  550.         pCountry* := n1;
  551.         true
  552.     fi
  553.     fi
  554. corp;
  555.  
  556. /*
  557.  * reqCountry - get (promting if needed) a country name or number.
  558.  */
  559.  
  560. proc reqCountry(*uint pCountry; *char prompt)bool:
  561.     bool gotOne;
  562.  
  563.     if InputPtr* = '\e' then
  564.     gotOne := true;
  565.     while
  566.         write(PromptOut; prompt);
  567.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  568.             InputBuffer[0] = '\e' then
  569.         gotOne := false;
  570.         false
  571.         else
  572.         InputPtr := &InputBuffer[0];
  573.         skipBlanks();
  574.         not getCountry(pCountry)
  575.         fi
  576.     do
  577.     od;
  578.     gotOne
  579.     else
  580.     getCountry(pCountry)
  581.     fi
  582. corp;
  583.  
  584. /*
  585.  * getChoice - see below.
  586.  */
  587.  
  588. proc getChoice(*uint pWhat; *char choices)bool:
  589.     *char p, q;
  590.     uint result;
  591.  
  592.     p := InputPtr;
  593.     skipWord();
  594.     q := InputPtr;
  595.     skipBlanks();
  596.     q* := '\e';
  597.     result := lookupCommand(choices, p);
  598.     if result = 0 then
  599.     err("unknown 'what'");
  600.     false
  601.     elif result = 1 then
  602.     err("ambiguous 'what'");
  603.     false
  604.     else
  605.     pWhat* := result - 2;
  606.     true
  607.     fi
  608. corp;
  609.  
  610. /*
  611.  * reqChoice - get and check a word from a given set of choices. Just complain
  612.  *    if it's from the command line, else prompt for a correct one. Return
  613.  *    'true' if we get a correct choice and set the 'what' parameter to the
  614.  *    index of the choice in choices (0 origin).
  615.  */
  616.  
  617. proc reqChoice(*uint pWhat; *char choices, prompt)bool:
  618.     bool quit, gotOne;
  619.  
  620.     if InputPtr* = '\e' then
  621.     gotOne := true;
  622.     while
  623.         write(PromptOut; prompt);
  624.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  625.             InputBuffer[0] = '\e' then
  626.         gotOne := false;
  627.         false
  628.         else
  629.         InputPtr := &InputBuffer[0];
  630.         skipBlanks();
  631.         not getChoice(pWhat, choices)
  632.         fi
  633.     do
  634.     od;
  635.     gotOne
  636.     else
  637.     getChoice(pWhat, choices)
  638.     fi
  639. corp;
  640.  
  641. /*
  642.  * getShip - get a ship number from the input line.
  643.  */
  644.  
  645. proc getShip(*uint pShip)bool:
  646.     int n;
  647.     uint n1;
  648.  
  649.     if InputPtr* = '\e' then
  650.     false
  651.     else
  652.     if getNumber(&n) then
  653.         n1 := n;
  654.         if n >= 0 and n1 < World.w_shipNext then
  655.         pShip* := n1;
  656.         true
  657.         else
  658.         err("ship number out of range");
  659.         false
  660.         fi
  661.     else
  662.         false
  663.     fi
  664.     fi
  665. corp;
  666.  
  667. /*
  668.  * reqShip - get (promting if needed) a ship number.
  669.  */
  670.  
  671. proc reqShip(*uint pShip; *char prompt)bool:
  672.     bool gotOne;
  673.  
  674.     if InputPtr* = '\e' then
  675.     gotOne := true;
  676.     while
  677.         write(PromptOut; prompt);
  678.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  679.             InputBuffer[0] = '\e' then
  680.         gotOne := false;
  681.         false
  682.         else
  683.         InputPtr := &InputBuffer[0];
  684.         skipBlanks();
  685.         not getShip(pShip)
  686.         fi
  687.     do
  688.     od;
  689.     gotOne
  690.     else
  691.     getShip(pShip)
  692.     fi
  693. corp;
  694.  
  695. /*
  696.  * getSectorOrShip - get a sector or ship spec.
  697.  */
  698.  
  699. proc getSectorOrShip(*int pA, pB; *uint pS; *bool pIsShip)bool:
  700.     *char p;
  701.  
  702.     p := InputPtr;
  703.     if p* = '-' then
  704.     /* has to be a sector spec */
  705.     pIsShip* := false;
  706.     getSector(pA, pB)
  707.     else
  708.     while p* >= '0' and p* <= '9' do
  709.         p := p + sizeof(char);
  710.     od;
  711.     if p* = ',' then
  712.         pIsShip* := false;
  713.         getSector(pA, pB)
  714.     else
  715.         pIsShip* := true;
  716.         getShip(pS)
  717.     fi
  718.     fi
  719. corp;
  720.  
  721. /*
  722.  * reqSectorOrShip - get (prompting if needed) a single sector or ship spec.
  723.  */
  724.  
  725. proc reqSectorOrShip(*int pA, pB; *uint pS; *bool pIsShip; *char prompt)bool:
  726.     bool gotOne;
  727.  
  728.     if InputPtr* = '\e' then
  729.     gotOne := true;
  730.     while
  731.         write(PromptOut; prompt);
  732.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  733.             InputBuffer[0] = '\e' then
  734.         gotOne := false;
  735.         false
  736.         else
  737.         InputPtr := &InputBuffer[0];
  738.         skipBlanks();
  739.         not getSectorOrShip(pA, pB, pS, pIsShip)
  740.         fi
  741.     do
  742.     od;
  743.     gotOne
  744.     else
  745.     getSectorOrShip(pA, pB, pS, pIsShip)
  746.     fi
  747. corp;
  748.  
  749. /*
  750.  * getShipOrFleet - get a ship number or fleet letter.
  751.  */
  752.  
  753. proc getShipOrFleet(*uint pShipNumber; *char pFleet)bool:
  754.  
  755.     if InputPtr* >= '0' and InputPtr* <= '9' then
  756.     pFleet* := ' ';
  757.     if getShip(pShipNumber) then
  758.         if InputPtr* = ' ' or InputPtr* = '\t' or InputPtr* = '\e' then
  759.         true
  760.         else
  761.         err("extraneous characters after ship number");
  762.         false
  763.         fi
  764.     else
  765.         false
  766.     fi
  767.     elif InputPtr* >= 'a' and InputPtr* <= 'z' or
  768.         InputPtr* >= 'A' and InputPtr* <= 'Z' or InputPtr* = '*' then
  769.     pFleet* := InputPtr*;
  770.     InputPtr := InputPtr + sizeof(char);
  771.     true
  772.     else
  773.     err("invalid fleet character");
  774.     InputPtr* := '\e';
  775.     false
  776.     fi
  777. corp;
  778.  
  779. /*
  780.  * reqShipOrFleet - request a ship number or fleet letter. Return a fleet
  781.  *    letter of ' ' if a ship number is given.
  782.  */
  783.  
  784. proc reqShipOrFleet(*uint pShipNumber; *char pFleet, prompt)bool:
  785.     bool gotOne;
  786.  
  787.     if InputPtr* = '\e' then
  788.     gotOne := true;
  789.     while
  790.         write(Chout; prompt);
  791.         if not readLine(&InputBuffer[0], INPUT_LENGTH) or
  792.             InputBuffer[0] = '\e' then
  793.         gotOne := false;
  794.         false
  795.         else
  796.         InputPtr := &InputBuffer[0];
  797.         skipBlanks();
  798.         not getShipOrFleet(pShipNumber, pFleet)
  799.         fi
  800.     do
  801.     od;
  802.     gotOne
  803.     else
  804.     getShipOrFleet(pShipNumber, pFleet)
  805.     fi
  806. corp;
  807.